home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / ntfs / attrib.h next >
C/C++ Source or Header  |  2005-10-18  |  13KB  |  349 lines
  1. /*
  2.  * attrib.h - Exports for attribute handling. Part of the Linux-NTFS project.
  3.  *
  4.  * Copyright (c) 2000-2004 Anton Altaparmakov
  5.  * Copyright (c) 2004-2005 Yura Pakhuchiy
  6.  *
  7.  * This program/include file is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU General Public License as published
  9.  * by the Free Software Foundation; either version 2 of the License, or
  10.  * (at your option) any later version.
  11.  *
  12.  * This program/include file is distributed in the hope that it will be
  13.  * useful, but WITHOUT ANY WARRANTY; without even the implied warranty
  14.  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15.  * GNU General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU General Public License
  18.  * along with this program (in the main directory of the Linux-NTFS
  19.  * distribution in the file COPYING); if not, write to the Free Software
  20.  * Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21.  */
  22.  
  23. #ifndef _NTFS_ATTRIB_H
  24. #define _NTFS_ATTRIB_H
  25.  
  26. /* Forward declarations */
  27. typedef struct _ntfs_attr ntfs_attr;
  28. typedef struct _ntfs_attr_search_ctx ntfs_attr_search_ctx;
  29.  
  30. #include "types.h"
  31. #include "inode.h"
  32. #include "unistr.h"
  33. #include "runlist.h"
  34. #include "volume.h"
  35. #include "debug.h"
  36.  
  37. extern ntfschar AT_UNNAMED[];
  38.  
  39. /**
  40.  * ntfs_lcn_special_values - special return values for ntfs_*_vcn_to_lcn()
  41.  *
  42.  * Special return values for ntfs_rl_vcn_to_lcn() and ntfs_attr_vcn_to_lcn().
  43.  *
  44.  * TODO: Describe them.
  45.  */
  46. typedef enum {
  47.     LCN_HOLE        = -1,    /* Keep this as highest value or die! */
  48.     LCN_RL_NOT_MAPPED    = -2,
  49.     LCN_ENOENT        = -3,
  50.     LCN_EINVAL        = -4,
  51.     LCN_EIO            = -5,
  52. } ntfs_lcn_special_values;
  53.  
  54. /**
  55.  * ntfs_attr_search_ctx - search context used in attribute search functions
  56.  * @mrec:    buffer containing mft record to search
  57.  * @attr:    attribute record in @mrec where to begin/continue search
  58.  * @is_first:    if true lookup_attr() begins search with @attr, else after @attr
  59.  *
  60.  * Structure must be initialized to zero before the first call to one of the
  61.  * attribute search functions. Initialize @mrec to point to the mft record to
  62.  * search, and @attr to point to the first attribute within @mrec (not necessary
  63.  * if calling the _first() functions), and set @is_first to TRUE (not necessary
  64.  * if calling the _first() functions).
  65.  *
  66.  * If @is_first is TRUE, the search begins with @attr. If @is_first is FALSE,
  67.  * the search begins after @attr. This is so that, after the first call to one
  68.  * of the search attribute functions, we can call the function again, without
  69.  * any modification of the search context, to automagically get the next
  70.  * matching attribute.
  71.  */
  72. struct _ntfs_attr_search_ctx {
  73.     MFT_RECORD *mrec;
  74.     ATTR_RECORD *attr;
  75.     BOOL is_first;
  76.     ntfs_inode *ntfs_ino;
  77.     ATTR_LIST_ENTRY *al_entry;
  78.     ntfs_inode *base_ntfs_ino;
  79.     MFT_RECORD *base_mrec;
  80.     ATTR_RECORD *base_attr;
  81. };
  82.  
  83. extern void ntfs_attr_reinit_search_ctx(ntfs_attr_search_ctx *ctx);
  84. extern ntfs_attr_search_ctx *ntfs_attr_get_search_ctx(ntfs_inode *ni,
  85.         MFT_RECORD *mrec);
  86. extern void ntfs_attr_put_search_ctx(ntfs_attr_search_ctx *ctx);
  87.  
  88. extern int ntfs_attr_lookup(const ATTR_TYPES type, const ntfschar *name,
  89.         const u32 name_len, const IGNORE_CASE_BOOL ic,
  90.         const VCN lowest_vcn, const u8 *val, const u32 val_len,
  91.         ntfs_attr_search_ctx *ctx);
  92.  
  93. extern ATTR_DEF *ntfs_attr_find_in_attrdef(const ntfs_volume *vol,
  94.         const ATTR_TYPES type);
  95.  
  96. /**
  97.  * ntfs_attrs_walk - syntactic sugar for walking all attributes in an inode
  98.  * @ctx:    initialised attribute search context
  99.  *
  100.  * Syntactic sugar for walking attributes in an inode.
  101.  *
  102.  * Return 0 on success and -1 on error with errno set to the error code from
  103.  * ntfs_attr_lookup().
  104.  *
  105.  * Example: When you want to enumerate all attributes in an open ntfs inode
  106.  *        @ni, you can simply do:
  107.  *
  108.  *    int err;
  109.  *    ntfs_attr_search_ctx *ctx = ntfs_attr_get_search_ctx(ni, NULL);
  110.  *    if (!ctx)
  111.  *        // Error code is in errno. Handle this case.
  112.  *    while (!(err = ntfs_attrs_walk(ctx))) {
  113.  *        ATTR_RECORD *attr = ctx->attr;
  114.  *        // attr now contains the next attribute. Do whatever you want
  115.  *        // with it and then just continue with the while loop.
  116.  *    }
  117.  *    if (err && errno != ENOENT)
  118.  *        // Ooops. An error occurred! You should handle this case.
  119.  *    // Now finished with all attributes in the inode.
  120.  */
  121. static __inline__ int ntfs_attrs_walk(ntfs_attr_search_ctx *ctx)
  122. {
  123.     return ntfs_attr_lookup(AT_UNUSED, NULL, 0, CASE_SENSITIVE, 0,
  124.             NULL, 0, ctx);
  125. }
  126.  
  127. /**
  128.  * ntfs_attr - ntfs in memory non-resident attribute structure
  129.  * @rl:            if not NULL, the decompressed runlist
  130.  * @ni:            base ntfs inode to which this attribute belongs
  131.  * @type:        attribute type
  132.  * @name:        Unicode name of the attribute
  133.  * @name_len:        length of @name in Unicode characters
  134.  * @state:        NTFS attribute specific flags describing this attribute
  135.  * @allocated_size:    copy from the attribute record
  136.  * @data_size:        copy from the attribute record
  137.  * @initialized_size:    copy from the attribute record
  138.  * @compressed_size:     copy from the attribute record
  139.  * @compression_block_size:        size of a compression block (cb)
  140.  * @compression_block_size_bits:    log2 of the size of a cb
  141.  * @compression_block_clusters:        number of clusters per cb
  142.  *
  143.  * This structure exists purely to provide a mechanism of caching the runlist
  144.  * of an attribute. If you want to operate on a particular attribute extent,
  145.  * you should not be using this structure at all. If you want to work with a
  146.  * resident attribute, you should not be using this structure at all. As a
  147.  * fail-safe check make sure to test NAttrNonResident() and if it is false, you
  148.  * know you shouldn't be using this structure.
  149.  *
  150.  * If you want to work on a resident attribute or on a specific attribute
  151.  * extent, you should use ntfs_lookup_attr() to retrieve the attribute (extent)
  152.  * record, edit that, and then write back the mft record (or set the
  153.  * corresponding ntfs inode dirty for delayed write back).
  154.  *
  155.  * @rl is the decompressed runlist of the attribute described by this
  156.  * structure. Obviously this only makes sense if the attribute is not resident,
  157.  * i.e. NAttrNonResident() is true. If the runlist hasn't been decompressed yet
  158.  * @rl is NULL, so be prepared to cope with @rl == NULL.
  159.  *
  160.  * @ni is the base ntfs inode of the attribute described by this structure.
  161.  *
  162.  * @type is the attribute type (see layout.h for the definition of ATTR_TYPES),
  163.  * @name and @name_len are the little endian Unicode name and the name length
  164.  * in Unicode characters of the attribute, respectively.
  165.  *
  166.  * @state contains NTFS attribute specific flags describing this attribute
  167.  * structure. See ntfs_attr_state_bits above.
  168.  */
  169. struct _ntfs_attr {
  170.     runlist_element *rl;
  171.     ntfs_inode *ni;
  172.     ATTR_TYPES type;
  173.     ntfschar *name;
  174.     u32 name_len;
  175.     unsigned long state;
  176.     s64 allocated_size;
  177.     s64 data_size;
  178.     s64 initialized_size;
  179.     s64 compressed_size;
  180.     u32 compression_block_size;
  181.     u8 compression_block_size_bits;
  182.     u8 compression_block_clusters;
  183. };
  184.  
  185. /**
  186.  * ntfs_attr_state_bits - bits for the state field in the ntfs_attr structure
  187.  */
  188. typedef enum {
  189.     NA_Initialized,        /* 1: structure is initialized. */
  190.     NA_NonResident,        /* 1: Attribute is not resident. */
  191. } ntfs_attr_state_bits;
  192.  
  193. #define  test_nattr_flag(na, flag)     test_bit(NA_##flag, (na)->state)
  194. #define   set_nattr_flag(na, flag)      set_bit(NA_##flag, (na)->state)
  195. #define clear_nattr_flag(na, flag)    clear_bit(NA_##flag, (na)->state)
  196.  
  197. #define NAttrInitialized(na)         test_nattr_flag(na, Initialized)
  198. #define NAttrSetInitialized(na)          set_nattr_flag(na, Initialized)
  199. #define NAttrClearInitialized(na)    clear_nattr_flag(na, Initialized)
  200.  
  201. #define NAttrNonResident(na)         test_nattr_flag(na, NonResident)
  202. #define NAttrSetNonResident(na)          set_nattr_flag(na, NonResident)
  203. #define NAttrClearNonResident(na)    clear_nattr_flag(na, NonResident)
  204.  
  205. #define GenNAttrIno(flag)                    \
  206. static inline int NAttr##flag(ntfs_attr *na)            \
  207. {                                \
  208.     if (na->type == AT_DATA && na->name == AT_UNNAMED)    \
  209.         return NIno##flag(na->ni);            \
  210.     return 0;                        \
  211. }                                \
  212. static inline void NAttrSet##flag(ntfs_attr *na)        \
  213. {                                \
  214.     if (na->type == AT_DATA && na->name == AT_UNNAMED)    \
  215.         NInoSet##flag(na->ni);                \
  216.     else                            \
  217.         Dprintf("%s(): BUG! Should be called only for "    \
  218.             "unnamed data attribute.\n",        \
  219.             __FUNCTION__);                \
  220. }                                \
  221. static inline void NAttrClear##flag(ntfs_attr *na)        \
  222. {                                \
  223.     if (na->type == AT_DATA && na->name == AT_UNNAMED)    \
  224.         NInoClear##flag(na->ni);            \
  225. }
  226.  
  227. GenNAttrIno(Compressed)
  228. GenNAttrIno(Encrypted)
  229. GenNAttrIno(Sparse)
  230.  
  231. /*
  232.  * Union of all known attribute values. For convenience. Used in the attr
  233.  * structure.
  234.  */
  235. typedef union {
  236.     u8 _default;    /* Unnamed u8 to serve as default when just using
  237.                a_val without specifying any of the below. */
  238.     STANDARD_INFORMATION std_inf;
  239.     ATTR_LIST_ENTRY al_entry;
  240.     FILE_NAME_ATTR filename;
  241.     OBJECT_ID_ATTR obj_id;
  242.     SECURITY_DESCRIPTOR_ATTR sec_desc;
  243.     VOLUME_NAME vol_name;
  244.     VOLUME_INFORMATION vol_inf;
  245.     DATA_ATTR data;
  246.     INDEX_ROOT index_root;
  247.     INDEX_BLOCK index_blk;
  248.     BITMAP_ATTR bmp;
  249.     REPARSE_POINT reparse;
  250.     EA_INFORMATION ea_inf;
  251.     EA_ATTR ea;
  252.     PROPERTY_SET property_set;
  253.     LOGGED_UTILITY_STREAM logged_util_stream;
  254.     EFS_ATTR_HEADER efs;
  255. } attr_val;
  256.  
  257. extern void ntfs_attr_init(ntfs_attr *na, const BOOL non_resident,
  258.         const BOOL compressed, const BOOL encrypted, const BOOL sparse,
  259.         const s64 allocated_size, const s64 data_size,
  260.         const s64 initialized_size, const s64 compressed_size,
  261.         const u8 compression_unit);
  262.  
  263. extern ntfs_attr *ntfs_attr_open(ntfs_inode *ni, const ATTR_TYPES type,
  264.         ntfschar *name, u32 name_len);
  265. extern void ntfs_attr_close(ntfs_attr *na);
  266.  
  267. extern s64 ntfs_attr_pread(ntfs_attr *na, const s64 pos, s64 count,
  268.         void *b);
  269. extern s64 ntfs_attr_pwrite(ntfs_attr *na, const s64 pos, s64 count,
  270.         const void *b);
  271.  
  272. extern s64 ntfs_attr_mst_pread(ntfs_attr *na, const s64 pos,
  273.         const s64 bk_cnt, const u32 bk_size, void *dst);
  274. extern s64 ntfs_attr_mst_pwrite(ntfs_attr *na, const s64 pos,
  275.         s64 bk_cnt, const u32 bk_size, void *src);
  276.  
  277. extern int ntfs_attr_map_runlist(ntfs_attr *na, VCN vcn);
  278. extern int ntfs_attr_map_whole_runlist(ntfs_attr *na);
  279.  
  280. extern LCN ntfs_attr_vcn_to_lcn(ntfs_attr *na, const VCN vcn);
  281. extern runlist_element *ntfs_attr_find_vcn(ntfs_attr *na, const VCN vcn);
  282.  
  283. extern int ntfs_attr_size_bounds_check(const ntfs_volume *vol,
  284.         const ATTR_TYPES type, const s64 size);
  285. extern int ntfs_attr_can_be_non_resident(const ntfs_volume *vol,
  286.         const ATTR_TYPES type);
  287. extern int ntfs_attr_can_be_resident(const ntfs_volume *vol,
  288.         const ATTR_TYPES type);
  289.  
  290. extern int ntfs_make_room_for_attr(MFT_RECORD *m, u8 *pos, u32 size);
  291.  
  292. extern int ntfs_resident_attr_record_add(ntfs_inode *ni, ATTR_TYPES type,
  293.         ntfschar *name, u8 name_len, u8 *val, u32 size,
  294.         ATTR_FLAGS flags);
  295. extern int ntfs_non_resident_attr_record_add(ntfs_inode *ni, ATTR_TYPES type,
  296.         ntfschar *name, u8 name_len, VCN lowest_vcn, int dataruns_size,
  297.         ATTR_FLAGS flags);
  298. extern int ntfs_attr_record_rm(ntfs_attr_search_ctx *ctx);
  299.  
  300. extern int ntfs_attr_add(ntfs_inode *ni, ATTR_TYPES type,
  301.         ntfschar *name, u8 name_len, u8 *val, s64 size);
  302. extern int ntfs_attr_rm(ntfs_attr *na);
  303.  
  304. extern int ntfs_attr_record_resize(MFT_RECORD *m, ATTR_RECORD *a, u32 new_size);
  305.  
  306. extern int ntfs_resident_attr_value_resize(MFT_RECORD *m, ATTR_RECORD *a,
  307.         const u32 newsize);
  308.  
  309. extern int ntfs_attr_record_move_to(ntfs_attr_search_ctx *ctx, ntfs_inode *ni);
  310. extern int ntfs_attr_record_move_away(ntfs_attr_search_ctx *ctx, int extra);
  311.  
  312. extern int ntfs_attr_update_mapping_pairs(ntfs_attr *na);
  313.  
  314. extern int ntfs_attr_truncate(ntfs_attr *na, const s64 newsize);
  315.  
  316. // FIXME / TODO: Above here the file is cleaned up. (AIA)
  317. /**
  318.  * get_attribute_value_length - return the length of the value of an attribute
  319.  * @a:    pointer to a buffer containing the attribute record
  320.  *
  321.  * Return the byte size of the attribute value of the attribute @a (as it
  322.  * would be after eventual decompression and filling in of holes if sparse).
  323.  * If we return 0, check errno. If errno is 0 the actual length was 0,
  324.  * otherwise errno describes the error.
  325.  *
  326.  * FIXME: Describe possible errnos.
  327.  */
  328. s64 ntfs_get_attribute_value_length(const ATTR_RECORD *a);
  329.  
  330. /**
  331.  * get_attribute_value - return the attribute value of an attribute
  332.  * @vol:    volume on which the attribute is present
  333.  * @a:        attribute to get the value of
  334.  * @b:        destination buffer for the attribute value
  335.  *
  336.  * Make a copy of the attribute value of the attribute @a into the destination
  337.  * buffer @b. Note, that the size of @b has to be at least equal to the value
  338.  * returned by get_attribute_value_length(@a).
  339.  *
  340.  * Return number of bytes copied. If this is zero check errno. If errno is 0
  341.  * then nothing was read due to a zero-length attribute value, otherwise
  342.  * errno describes the error.
  343.  */
  344. s64 ntfs_get_attribute_value(const ntfs_volume *vol, const ATTR_RECORD *a,
  345.         u8 *b);
  346.  
  347. #endif /* defined _NTFS_ATTRIB_H */
  348.  
  349.